home *** CD-ROM | disk | FTP | other *** search
/ Chip: 2001 Haziran / CHIP Haziran2001.iso / prog / haziran / 19 / setup.exe / data.z / p9060_diag.c < prev    next >
C/C++ Source or Header  |  2001-04-11  |  14KB  |  392 lines
  1. ////////////////////////////////////////////////////////////////
  2. // File - P9060_DIAG.C
  3. //
  4. // o A simple diagnostics program that lets you access the
  5. //   PLX 9060 registers and local memory. 
  6. // o This program is meant to be used as an example for using the P9060_LIB.H API,
  7. //   you may use it as a skeleton for your driver, or 'cut & paste' parts
  8. //   of it into your device driver code.
  9. // o For a more advanced monitor program, use the standard PLXMON.EXE
  10. //   from PLX.
  11. // 
  12. ////////////////////////////////////////////////////////////////
  13.  
  14. #include "../../../include/windrvr.h"
  15. #include "../lib/p9060_lib.h"
  16. #include "../../../samples/shared/pci_diag_lib.h"
  17. #include <stdio.h>
  18.  
  19. // input of command from user
  20. static char line[256];
  21.  
  22. void PLX_EditReg(P9060_HANDLE hPlx)
  23. {
  24.     struct 
  25.     {
  26.         CHAR *name;
  27.         DWORD dwOffset;
  28.         DWORD dwVal;
  29.     } fields[30];
  30.  
  31.     int cmd;
  32.     int i;
  33.     int field_count;
  34.  
  35.     i = 0;
  36.     fields[i].name = "LAS0RR"; fields[i++].dwOffset = 0x00;
  37.     fields[i].name = "LAS0BA"; fields[i++].dwOffset = 0x04;
  38.     fields[i].name = "EROMRR"; fields[i++].dwOffset = 0x10;
  39.     fields[i].name = "EROMBA"; fields[i++].dwOffset = 0x14;
  40.     fields[i].name = "LBRD0"; fields[i++].dwOffset = 0x18;
  41.     fields[i].name = "MBOX0"; fields[i++].dwOffset = 0x40;
  42.     fields[i].name = "MBOX1"; fields[i++].dwOffset = 0x44;
  43.     fields[i].name = "MBOX2"; fields[i++].dwOffset = 0x48;
  44.     fields[i].name = "MBOX3"; fields[i++].dwOffset = 0x4c;
  45.     fields[i].name = "MBOX4"; fields[i++].dwOffset = 0x50;
  46.     fields[i].name = "MBOX5"; fields[i++].dwOffset = 0x54;
  47.     fields[i].name = "MBOX6"; fields[i++].dwOffset = 0x58;
  48.     fields[i].name = "MBOX7"; fields[i++].dwOffset = 0x5c;
  49.     fields[i].name = "P2LDBELL"; fields[i++].dwOffset = 0x60;
  50.     fields[i].name = "L2PDBELL"; fields[i++].dwOffset = 0x64;
  51.     fields[i].name = "INTCSR"; fields[i++].dwOffset = 0x68;
  52.     fields[i].name = "CNTRL"; fields[i++].dwOffset = 0x6c;
  53.     field_count = i;
  54.     do
  55.     {
  56.         int row;
  57.         int col;
  58.         int row_count = field_count/2 + field_count%2;
  59.  
  60.         printf ("\n");
  61.         printf ("Edit PLX 9060 registers\n");
  62.         printf ("--------------------------------\n");
  63.         for (row = 0; row<row_count; row++)
  64.         {
  65.             for (col = 0; col<=1; col++)
  66.             {
  67.                 if (col==0) i = row;
  68.                 else i = row + row_count;
  69.  
  70.                 if (i<field_count)
  71.                 {
  72.                     char buf[10];
  73.                     fields[i].dwVal = P9060_ReadReg(hPlx, fields[i].dwOffset);
  74.                     sprintf(buf, "%08x",fields[i].dwVal);
  75.                     printf ("%2d. %7s : %s     ",i+1, fields[i].name, buf);
  76.                 }
  77.                 if (col==1) printf ("\n");
  78.             }
  79.         }
  80.  
  81.         printf ("99. Back to main menu\n");
  82.         printf ("Choose register to write to, or 99 to exit: ");
  83.         cmd = 0;
  84.         fgets(line, sizeof(line), stdin);
  85.         sscanf (line, "%d",&cmd);
  86.         if (cmd>=1 && cmd <=21)
  87.         {
  88.             i = cmd-1;
  89.             printf ("Enter value to write to %s register (or 'X' to cancel): ",fields[i].name);
  90.             fgets(line, sizeof(line), stdin);
  91.             if (toupper (line[0])!='X')
  92.             {
  93.                 DWORD dwVal;
  94.                 dwVal = 0;
  95.                 sscanf (line,"%x",&dwVal);
  96.                 P9060_WriteReg(hPlx, fields[i].dwOffset, dwVal);
  97.             }
  98.         }
  99.     } while (cmd!=99);
  100. }
  101.  
  102. char *PLX_GetAddrRangeName(P9060_ADDR addrSpace)
  103. {
  104.     return 
  105.         addrSpace==P9060_ADDR_SPACE0 ? "Addr Space 0 - (BAR2)" :
  106.         addrSpace==P9060_ADDR_SPACE1 ? "Addr Space 1 - (BAR3)" :
  107.         addrSpace==P9060_ADDR_SPACE2 ? "Addr Space 2 - (BAR4)" :
  108.         addrSpace==P9060_ADDR_SPACE3 ? "Addr Space 3 - (BAR5)" :
  109.         addrSpace==P9060_ADDR_EPROM ? "EEPROM Addr Space" : "Invalid";
  110. }
  111.  
  112. void PLX_BoardAccess(P9060_HANDLE hPlx, BOOL fLocalAddr)
  113. {
  114.     int cmd, cmd2, i;
  115.     DWORD addr, data;
  116.     P9060_ADDR ad_sp = P9060_ADDR_SPACE0;
  117.     P9060_MODE ad_mode = P9060_MODE_DWORD;
  118.     char *pcMemoryType = fLocalAddr ? "local address" : "offset";
  119.  
  120.     if (!fLocalAddr)
  121.     {
  122.         for (; ad_sp<=P9060_ADDR_EPROM && !P9060_IsAddrSpaceActive(hPlx, ad_sp); ad_sp++)
  123.         if (ad_sp>P9060_ADDR_EPROM)
  124.         {
  125.             printf ("No active memory spaces on board!\n");
  126.             return;
  127.         }
  128.     }
  129.  
  130.     do
  131.     {
  132.         printf ("Access the board's %s ranges\n",pcMemoryType);
  133.         printf ("-------------------------------------------\n");
  134.         printf ("(Access to invalid %s may hang the computer!)\n", pcMemoryType);
  135.         if (!fLocalAddr)
  136.             printf ("1. Change active memory space: %s\n",PLX_GetAddrRangeName(ad_sp));
  137.         printf ("2. Toggle active mode: %s\n", 
  138.             ad_mode==P9060_MODE_BYTE ? "BYTE (8 bit)" :
  139.             ad_mode==P9060_MODE_WORD ? "WORD (16 bit)" : "DWORD (32 bit)");
  140.         printf ("3. Read from board\n");
  141.         printf ("4. Write to board\n");
  142.         printf ("99. Back to main menu\n");
  143.         printf ("\n");
  144.         printf ("Enter option: ");
  145.         cmd = 0;
  146.         fgets(line, sizeof(line), stdin);
  147.         sscanf (line, "%d",&cmd);
  148.         switch (cmd)
  149.         {
  150.         case 1:
  151.             if (!fLocalAddr)
  152.             {
  153.                 printf ("Choose memory space:\n");
  154.                 printf ("--------------------\n");
  155.                 for (i=P9060_ADDR_SPACE0; i<=P9060_ADDR_EPROM; i++)
  156.                 {
  157.                     printf ("%d. %s", i, PLX_GetAddrRangeName(i));
  158.                     if (P9060_IsAddrSpaceActive(hPlx, i)) printf ("\n");
  159.                     else printf (" - space not active\n");
  160.                 }
  161.                 printf ("Enter option: ");
  162.                 cmd2 = 99;
  163.                 fgets(line, sizeof(line), stdin);
  164.                 sscanf (line, "%d",&cmd2);
  165.                 if (cmd2>=P9060_ADDR_SPACE0 && cmd2<=P9060_ADDR_EPROM)
  166.                 {
  167.                     int new_ad_sp = cmd2;
  168.                     if (P9060_IsAddrSpaceActive(hPlx, new_ad_sp)) ad_sp = new_ad_sp;
  169.                     else printf ("Chosen space not active!\n");
  170.                 }
  171.             }
  172.             break;
  173.         case 2:
  174.             ad_mode = (ad_mode + 1) % 3;
  175.             break;
  176.         case 3:
  177.             printf ("Enter %s to read from: ", pcMemoryType);
  178.             fgets(line, sizeof(line), stdin);
  179.             sscanf (line, "%x", &addr);
  180.             switch (ad_mode)
  181.             {
  182.             case P9060_MODE_BYTE:
  183.                 if (fLocalAddr) data = P9060_ReadByte(hPlx, addr);
  184.                 else data = P9060_ReadSpaceByte(hPlx, ad_sp, addr);
  185.                 break;
  186.             case P9060_MODE_WORD:
  187.                 if (fLocalAddr) data = P9060_ReadWord(hPlx, addr);
  188.                 else data = P9060_ReadSpaceWord(hPlx, ad_sp, addr);
  189.                 break;
  190.             case P9060_MODE_DWORD:
  191.                 if (fLocalAddr) data = P9060_ReadDWord(hPlx, addr);
  192.                 else data = P9060_ReadSpaceDWord(hPlx, ad_sp, addr);
  193.                 break;
  194.             }
  195.             printf ("Value read: %x\n", data);
  196.             break;
  197.         case 4:
  198.             printf ("Enter %s to write to: ", pcMemoryType);
  199.             fgets(line, sizeof(line), stdin);
  200.             sscanf (line, "%x", &addr);
  201.             printf ("Enter data to write %s: ",
  202.                 ad_mode==P9060_MODE_BYTE ? "BYTE (8 bit)" :
  203.                 ad_mode==P9060_MODE_WORD ? "WORD (16 bit)" : "DWORD (32 bit)");
  204.             fgets(line, sizeof(line), stdin);
  205.             sscanf (line, "%x",&data);
  206.             switch (ad_mode)
  207.             {
  208.             case P9060_MODE_BYTE:
  209.                 if (fLocalAddr) P9060_WriteByte(hPlx, addr, (BYTE) data);
  210.                 else P9060_WriteSpaceByte(hPlx, ad_sp, addr, (BYTE) data);
  211.                 break;
  212.             case P9060_MODE_WORD:
  213.                 if (fLocalAddr) P9060_WriteWord(hPlx, addr, (WORD) data);
  214.                 else P9060_WriteSpaceWord(hPlx, ad_sp, addr, (WORD) data);
  215.                 break;
  216.             case P9060_MODE_DWORD:
  217.                 if (fLocalAddr) P9060_WriteDWord(hPlx, addr, data);
  218.                 else P9060_WriteSpaceDWord(hPlx, ad_sp, addr, data);
  219.                 break;
  220.             }
  221.             break;
  222.         }
  223.     } while (cmd!=99);
  224. }
  225.  
  226. void WINAPI PLX_IntHandlerRoutine(P9060_HANDLE hPlx, P9060_INT_RESULT *intResult)
  227. {
  228.     printf ("Got interrupt number %d\n", intResult->dwCounter);
  229. }
  230.  
  231. void PLX_EnableDisableInterrupts(P9060_HANDLE hPlx)
  232. {
  233.     int cmd;
  234.  
  235.     printf ("WARNING!!!\n");
  236.     printf ("----------\n");
  237.     printf ("Your hardware has level sensitive interrupts.\n");
  238.     printf ("You must modify the source code of P9060_IntEnable(), in the file p9060_lib.c,\n");
  239.     printf ("to acknowledge the interrupt before enabling interrupts.\n");
  240.     printf ("Without this modification, your PC will HANG upon interrupt!\n");
  241.  
  242.     do
  243.     {
  244.         printf ("Enable / Disable interrupts\n");
  245.         printf ("---------------------------\n");
  246.         printf ("1. %s interrupts\n", P9060_IntIsEnabled(hPlx) ? "Disable" : "Enable");
  247.         printf ("99. Back to main menu\n");
  248.         printf ("\n");
  249.         printf ("Enter option: ");
  250.         cmd = 0;
  251.         fgets(line, sizeof(line), stdin);
  252.         sscanf (line, "%d",&cmd);
  253.         switch (cmd)
  254.         {
  255.         case 1:
  256.             if (P9060_IntIsEnabled(hPlx))
  257.             {
  258.                 printf ("Disabling interrupt Int\n");
  259.                 P9060_IntDisable(hPlx);
  260.             }
  261.             else
  262.             {
  263.                 printf ("Enabling interrupts\n");
  264.                 if (!P9060_IntEnable(hPlx, PLX_IntHandlerRoutine))
  265.                     printf ("failed enabling interrupts\n");
  266.             }
  267.             break;
  268.         }
  269.     } while (cmd!=99);
  270. }
  271.  
  272. P9060_HANDLE PLX_LocateAndOpenBoard(DWORD dwVendorID, DWORD dwDeviceID, BOOL fUseInt)
  273. {
  274.     DWORD cards, my_card;
  275.     P9060_HANDLE hPlx = NULL;
  276.  
  277.     if (dwVendorID==0)
  278.     {
  279.         printf ("Enter VendorID: ");
  280.         fgets(line, sizeof(line), stdin);
  281.         sscanf (line, "%x",&dwVendorID);
  282.         if (dwVendorID==0) return NULL;
  283.  
  284.         printf ("Enter DeviceID: ");
  285.         fgets(line, sizeof(line), stdin);
  286.         sscanf (line, "%x",&dwDeviceID);
  287.     }
  288.     cards = P9060_CountCards (dwVendorID, dwDeviceID);
  289.     if (cards==0) 
  290.     {
  291.         printf("%s", P9060_ErrorString);
  292.         return NULL;
  293.     }
  294.     else if (cards==1) my_card = 1;
  295.     else
  296.     {
  297.         DWORD i;
  298.  
  299.         printf("Found %d matching PCI cards\n", cards);
  300.         printf("Select card (1-%d): ", cards);
  301.         i = 0;
  302.         fgets(line, sizeof(line), stdin);
  303.         sscanf (line, "%d",&i);
  304.         if (i>=1 && i <=cards) my_card = i;
  305.         else 
  306.         {
  307.             printf ("Choice out of range\n");
  308.             return NULL;
  309.         }
  310.     }
  311.     if (P9060_Open (&hPlx, dwVendorID, dwDeviceID, my_card - 1, fUseInt ? P9060_OPEN_USE_INT : 0))
  312.         printf ("PLX 9060 PCI card found!\n");
  313.     else printf ("%s", P9060_ErrorString);
  314.     return hPlx;
  315. }
  316.  
  317. int main(int argc, char *argv[])
  318. {
  319.     int cmd;
  320.     P9060_HANDLE hPlx = NULL;
  321.     HANDLE hWD;
  322.     BOOL fUseInt = FALSE; // by default - do not install interrupts
  323.  
  324.     printf ("PLX 9060 diagnostic utility.\n");
  325.     printf ("Application accesses hardware using " WD_PROD_NAME ".\n");
  326.  
  327.     // make sure WinDriver is loaded
  328.     if (!PCI_Get_WD_handle(&hWD)) return 0;
  329.     WD_Close (hWD);
  330.  
  331.     hPlx = PLX_LocateAndOpenBoard(0x10b5, 0x9060, fUseInt);
  332.  
  333.     do
  334.     {
  335.         printf ("\n");
  336.         printf ("PLX 9060 main menu\n");
  337.         printf ("-------------------\n");
  338.         printf ("1. Scan PCI bus\n");
  339.         printf ("2. Set opening board %s interrupts\n", fUseInt ? "without" : "with");
  340.         printf ("3. Locate/Choose PLX 9060 board (%s interrupts)\n", fUseInt ? "with" : "without");
  341.         if (hPlx)
  342.         {
  343.             printf ("4. PCI configuration registers\n");
  344.             printf ("5. PLX 9060 local registers\n");
  345.             printf ("6. Access address spaces on the board\n");
  346.             printf ("7. Access local address ranges on the board\n");
  347.             if (hPlx->fUseInt)
  348.                 printf ("8. Enable / Disable interrupts\n");
  349.         }
  350.         printf ("99. Exit\n");
  351.         printf ("Enter option: ");
  352.         cmd = 0;
  353.         fgets(line, sizeof(line), stdin);
  354.         sscanf (line, "%d",&cmd);
  355.         switch (cmd)
  356.         {
  357.         case 1: // Scan PCI bus
  358.             PCI_Print_all_cards_info();
  359.             break;
  360.         case 2: // Set open board with / without interrupts
  361.             fUseInt = !fUseInt;
  362.             break;
  363.         case 3: // Locate PLX 9060 board
  364.             if (hPlx) P9060_Close(hPlx);
  365.             hPlx = PLX_LocateAndOpenBoard(0, 0, fUseInt);
  366.             if (!hPlx) printf ("PLX card open failed!\n");
  367.             break;
  368.         case 4: // PCI configuration registers
  369.             if (hPlx) PCI_EditConfigReg(hPlx->pciSlot);
  370.             break;
  371.         case 5: // PLX 9060 local registers
  372.             if (hPlx) PLX_EditReg(hPlx);
  373.             break;
  374.         case 6: // Access address spaces on the board
  375.             if (hPlx) PLX_BoardAccess(hPlx, FALSE);
  376.             break;
  377.         case 7: // Access local address ranges on the board
  378.             if (hPlx) PLX_BoardAccess(hPlx, TRUE);
  379.             break;
  380.         case 8: // Enable / Disable interrupts
  381.             if (hPlx && hPlx->fUseInt) PLX_EnableDisableInterrupts(hPlx);
  382.             break;
  383.         }
  384.     } while (cmd!=99);
  385.  
  386.     if (hPlx) P9060_Close(hPlx);
  387.  
  388.     return 0;
  389. }
  390.  
  391.                                       
  392.